home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 002 / chedit.arc / CGRAPHP.DOC < prev    next >
Encoding:
Text File  |  1986-07-23  |  18.6 KB  |  477 lines
  1. This material is placed in the public domain by its author, William Couture.
  2. Copyright (c) 1986 by DDI.  All Rights Reserved.
  3.  
  4.  
  5.               CHARACTER GRAPHICS ROUTINES AVAILABLE
  6.  
  7. GENERAL NOTES:
  8.      All routines work in 320 x 200 4-color mode or 640 x 200 mode.
  9.      COLOR is an integer between 0 and 3, inclusive, for 320 x 200 mode,
  10.           and between 0 and 1, inclusive, for 640 x 200 mode (0 = background).
  11.           Adding 128 to the color will XOR draw the character instead of
  12.           plotting it.  This will allow you to place characters on top of
  13.           already drawn graphics screens without leaving holes in the picture.
  14.      All the regular graphics routines are also available.
  15.      CROW (Character ROW) is an integer between 1 and 25, inclusive.
  16.      CCOL (Character COL) is an integer between 1 and 40, inclusive, for
  17.           320 x 200 mode, and between 1 and 80 for 640 x 200 mode.
  18.      Do not let ANY routine draw anything beyond a screen edge.
  19.      Character graphics can only be displaed in the spaces where normal
  20.                characters would be on a 25 x 40 screen for 320 x 200 mode,
  21.                and in the spaces where charcters would be on a 25 x 80
  22.                screen for 640 x 200 mode.
  23.      WCHAR is an integer between 0 and 127, inclusive.  This is the index to
  24.                the desired graphics character.
  25.      CSHAPES is the name of an array which contains the character shapes.    
  26.  
  27.  
  28.  
  29.  
  30.  
  31. TYPE DEFINITIONS AND VARIABLES:
  32.      Type CHARSET is a 1024 element of byte, which holds the character images
  33.      being used.  The definition is ARRAY[0..1023] OF BYTE with the array
  34.      base at 0 for correspondence with machine language references.
  35.  
  36.      Type FILENAME is simply an 80 character string, used to pass a filename
  37.      to the readcset and writecset functtions.  Its definition is STRING[80]
  38.  
  39.      Type CHARMESSAGE is defined to pass a "string" of graphics characters to
  40.      the procedures described below.  It is an array of integers, to bypass
  41.      the problems with signed and unsigned bytes/chars.  Its definition is
  42.      ARRAY[0..79] OF INTEGER
  43.  
  44.      The variables COLDSEG and COLDADDR stand for Character OLD SEGment and
  45.      Character OLD ADDress, respectively, and are used to store the previous
  46.      values of the character set pointer.  They are not needed if the GETVECT
  47.      and RESTOREVECT procedures are not used, and the names may be changed to
  48.      suit your tastes.
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57. ROUTINES:
  58.  
  59. function readcset(var cshapes:charset; fname:filename)
  60.      Try to read the character set named filename into memory.  The routine
  61.      will return -1 if fname cannot be found, else it will return 1.
  62.      
  63.      example:  errno := readcset(shapes,'myset.chr');
  64.                if errno = -1 then
  65.                   writeln('Error - character set not found.');
  66.                else
  67.                   run_program;
  68.  
  69.  
  70.  
  71.  
  72. function writecset(var cshapes:charset; fname:filename)
  73.      Write the current character set from memory to a disk file named fname.
  74.      The routine returns a -1 if the file cannot be created, else it returns
  75.      a 1.
  76.      
  77.      example:  errno := writecset(shapes,'c:\stuff\saved.chr');
  78.                if errno = -1 then
  79.                   writeln('Error - cannot open file to write character set.');
  80.                else
  81.                   writeln('Character set saved.');
  82.  
  83.  
  84.  
  85. procedure getvect
  86.      Save the system's graphics character set pointer.  This should only be
  87.      called once, before the start of using character graphics.  It also has
  88.      a companion routine, RESTOREVECT.
  89.  
  90.  
  91.  
  92.  
  93. procedure restorevect
  94.      Restore the system's graphics character set pointer.  It can be called
  95.      any number of times, but getvect MUST HAVE BEEN CALLED FIRST.
  96.  
  97.  
  98.  
  99. procedure setvect(var cshapes:charset)
  100.      Set the system to display your graphics character set.  This can be called
  101.      any number of times, to display differenct character sets.
  102.  
  103.  
  104.  
  105.  
  106.  
  107. procedure setbit(var cshapes:charset; wchar,row,col:integer)
  108.                             row and col are integers from 0 to 7, inclusive
  109.      Set the bit at row,col in WCHAR to ON.
  110.  
  111.  
  112.  
  113. procedure clearbit(var cshapes:charset; wchar,row,col:integer)
  114.                             row and col are integers from 0 to 7, inclusive
  115.      Set the bit at row,col in WCHAR to OFF.
  116.  
  117.  
  118.  
  119. procedure xorbit(var cshapes:charset; wchar,row,col:integer)
  120.                             row and col are integers from 0 to 7, inclusive
  121.      Set the bit at row,col in WCHAR to the opposite of its current state.
  122.  
  123.  
  124.  
  125. procedure zerochar(var cshapes:charset; wchar:integer)
  126.      Set all bits in WCHAR to OFF.
  127.  
  128.  
  129.  
  130. procedure fillchar(var cshapes:charset; wchar:integer)
  131.      Set all bits in WCHAR to ON.
  132.  
  133.  
  134.  
  135. procedure inversechar(var cshapes:charset; wchar:integer)
  136.      Set all bits in WCHAR to the opposite of their current state.
  137.  
  138.  
  139.  
  140. procedure copychar(var cshapes:charset; fromchar,intochar:integer)
  141.                            fromchar and intochar are two examples of WCHAR
  142.      Make the graphics character intochar the same as fromchar.
  143.  
  144.  
  145.  
  146. procedure horizflip(var cshapes:charset; wchar:integer)
  147.      Mirror WCHAR about its horizontal axis.
  148.  
  149.  
  150.  
  151. procedure vertflip(var cshapes:charset; wchar:integer)
  152.      Mirror WCHAR about its vertical axis.
  153.  
  154.  
  155.  
  156. procedure exchangerc(var cshapes:charset; wchar:integer)
  157.      Exchange rows and columns in WCHAR.
  158.  
  159.  
  160.  
  161. procedure shiftdown(var cshapes:charset; wchar:integer)
  162.      Move the picture in WCHAR down 1 row.  The bottom row is lost and the
  163.      top row is set to blank.
  164.  
  165.  
  166.  
  167. procedure shiftup(var cshapes:charset; wchar:integer)
  168.      Move the picture in WCHAR up 1 row.  The top row is lost and the bottom
  169.      row is set to blank.
  170.  
  171.  
  172.  
  173. procedure shiftleft(var cshapes:charset; wchar:integer)
  174.      Move the picture in WCHAR left 1 column.  The left column is lost and
  175.      the right column is set to blank.
  176.  
  177.  
  178.  
  179. procedure shiftright(var cshapes:charset; wchar:integer)
  180.      Move the picture in WCHAR right 1 column.  The right column is lost and
  181.      the left column is set to blank.
  182.  
  183.  
  184.  
  185. procedure rotatedown(var cshapes:charset; wchar:integer)
  186.      Move the picture in WCHAR down 1 row.  The bottom row wraps into the top
  187.      row.
  188.  
  189.  
  190.  
  191. procedure rotateup(var cshapes:charset; wchar:integer)
  192.      Move the picture in WCHAR up 1 row.  The top row wraps into the bottom
  193.      row.
  194.  
  195.  
  196.  
  197. procedure rotateleft(var cshapes:charset; wchar:integer)
  198.      Move the picture in WCHAR left 1 column.  The left column wraps into
  199.      the right column.
  200.  
  201.  
  202.  
  203. procedure rotateright(var cshapes:charset; wchar:integer)
  204.      Move the picture in WCHAR right 1 column.  The right column wraps into
  205.      the left column.
  206.  
  207.  
  208.  
  209. procedure grchar(wchar,color:integer)
  210.      Plot the graphics char WCHAR at the current cursor position in COLOR.
  211.      The routine may be modified so that adding 128 ($80 in hex) to the
  212.      WCHAR value will draw the normal ASCII character instead of the
  213.      graphics character.  See the comments in PCHR.I for details.
  214.      Adding 128 ($80 in hex) to the color will XOR draw the character,
  215.      placing it on top of the current screen image.
  216.  
  217.  
  218.  
  219. procedure gratchar(crow,ccol,wchar,color:integer)
  220.      Plot the graphics char WCHAR at CROW,CCOL in COLOR.
  221.      The routine may be modified so that adding 128 ($80 in hex) to the
  222.      WCHAR value will draw the normal ASCII character instead of the
  223.      graphics character.  See the comments in PCHR.I for details.
  224.      Adding 128 ($80 in hex) to the color will XOR draw the character,
  225.      placing it on top of the current screen image.
  226.  
  227.  
  228.  
  229. procedure printbanner(crow,ccol:integer; msg:charmessage; length,color:integer)
  230.                                 MSG is an array of integers which
  231.                                 contains the WCHAR codes for the banner
  232.                                 LENGTH is the number of elements in MSG
  233.      Move the cursor to CROW,CCOL and display the LENGTH graphics characters
  234.      from MSG across the screen in COLOR.  Please note that adding 128 ($80
  235.      in hex) to the color will XOR draw the characters, placing them on top
  236.      of the current screen image.
  237.  
  238.  
  239.  
  240.  
  241. procedure bannerleft(var cshapes:charset; var msg:charmessage; length:integer)
  242.                                 MSG is an array of integers which
  243.                                 contains the WCHAR codes for the banner.
  244.                                 LENGTH is the number of elements in MSG
  245.      Treat LENGTH elements of MSG as one extended graphics character and
  246.      rotate it left 1 column.  The column rolled off the left is wrapped back
  247.      on the right.
  248.  
  249.  
  250.  
  251. procedure bannerright(var cshapes:charset; var msg:charmessage; length:integer)
  252.                                 MSG is an array of integers which contains
  253.                                 the WCHAR codes for the banner.
  254.                                 LENGTH is the number of elements in MSG
  255.      Treat LENGTH elements of MSG as one extended graphics character and
  256.      rotate it right 1 column.  The column rolled off the right is wrapped back
  257.      to the left.
  258.  
  259.  
  260.  
  261. procedure bannerup(var cshapes:charset; var msg:charmessage; length:integer)
  262.                                MSG is an array of integers which contains
  263.                                the WCHAR codes for the banner.
  264.                                LENGTH is the number of elements in MSG
  265.      Move LENGTH elements of MSG up 1 row.  The row rotated off the top
  266.      wraps back to the bottom.  Note that any character may be individually
  267.      scrolled via the rotatexxxx() procedures above.
  268.  
  269.  
  270.  
  271. procedure bannerdown(var cshapes:charset; var msg:charmessage; length:integer)
  272.                                MSG is an array of integers, which contains
  273.                                the WCHAR codes for the banner.
  274.                                LENGTH is the number of elements in MSG
  275.      Move LENGTH elements of MSG down 1 row.  The row rotated off the
  276.      bottom wraps back to the top.  Note that any character may be individually
  277.      scrolled via the rotatexxxx() functions above.
  278.  
  279.  
  280. example:
  281.  
  282. program example1;
  283.  
  284. {$Ipchr.i  }    { Include the character routines.  THE SPACES AFTER THE .i }
  285.                 { EXTENSION MUST BE INCLUDED }
  286.  
  287. var
  288.       shapes : charset;        { the array to hold the character shapes }
  289.       message : charmessage;   { the array to hold the message to be plotted }
  290.       errno : integer;         { to hold the return value from READCSET }
  291.       i,m : integer;           { loop indices }
  292.  
  293. begin { main program }
  294.    errno := readcset(shapes,'alpha.chr');
  295.                                { read the character set }
  296.    if errno <> -1 then         { if all ok }
  297.       begin
  298.          graphcolormode;       { set to 320 x 200 graphics }
  299.          message[0] := 65;     { graphics character 65 }
  300.          message[1] := 67;     { etc. }
  301.          message[2] := 69;
  302.          getvect;              { save the system vector }
  303.          setvect(shapes);      { and insert our own }
  304.          printbanner(2,5,message,2,1);
  305.                                { print the message in color 1, cyan }
  306.                                { note that this displays only the first 2 }
  307.                                { characters, so the 3rd is "hidden" }
  308.          for i := 1 to 8*3*20 do
  309.                                { rotate through all 8 columns of the 3 chars }
  310.                                { 20 times }
  311.             begin
  312.                for m := 1 to 1500 do ;
  313.                                { waste a little time }
  314.                bannerleft(shapes,message,3);
  315.                                { rotate all left so all characters take turns
  316.                                  being hidden }
  317.                printbanner(2,5,message,2,1);
  318.                                { and display it again }
  319.             end;
  320.          for m := 0 to 30000 do ;
  321.                                { one last time delay }
  322.          restorevect;          { put the system vector back }
  323.          textmode;             { turn the graphics off }
  324.       end;                     { end of the if }
  325. end.                           { end of the program }
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334. procedure printcolumn(crow,ccol:integer; msg:charmessage; length,color:integer)
  335.                                MSG is an array of integers which contains
  336.                                the WCHAR codes for the column.
  337.                                LENGTH is the number of elements in MSG
  338.      Move the cursor to CROW,CCOL and display the LENGTH graphics chatacters
  339.      from MSG down the screen in COLOR.  Please note that adding 128 ($80
  340.      in hex) to the color will XOR draw the characters, placing them on top
  341.      of the current screen image.
  342.  
  343.  
  344.  
  345. procedure columnup(var cshapes:charset; var msg:charmessage; length:integer)
  346.                             MSG is an array of integers which contains
  347.                             the WCHAR codes for the column.
  348.                             LENGTH is the number of elements in MSG.
  349.      Treat LENGTH elements of MSG as one extended graphics character and
  350.      rotate it 1 row up.  The row that rolls off the top wraps to the bottom.
  351.  
  352.  
  353.  
  354. procedure columndown(var cshapes:charset; var msg:charmessage; length:integer)
  355.                                MSG is an array of integers which contains
  356.                                the WCHAR codes for the column.
  357.                                LENGTH is the number of elements in MSG.
  358.      Treat LENGTH elements of MSG as on extended graphics character and
  359.      rotate it 1 row down.  The row that rolls off the bottom wraps to the top.
  360.  
  361.  
  362.  
  363. procedure columnleft(var cshapes:charset; var msg:charmessage; length:integer)
  364.                                MSG is an array of integers which contains
  365.                                the WCHAR codes for the column.
  366.                                LENGTH is the number of elements in MSG.
  367.      Move LENGTH elements of MSG left 1 column.  The column rotated off the
  368.      left wraps to the right.  Note that any element of the column may be
  369.      scrolled by the rotatexxxx() functions above.
  370.  
  371.  
  372.  
  373. procedure columnright(var cshapes:charset; var msg:charmessage; length:integer)
  374.                                MSG is an array of integers which contains
  375.                                the WCHAR codes for the column.
  376.                                LENGTH is the number of elements in MSG.
  377.      Move LENGTH elements of MSG right 1 column.  The column rotated off
  378.      the right wraps to the left.  Note that any element of the column may be
  379.      scrolled by the rotatexxxx() functions above.
  380.  
  381.  
  382.  
  383.  
  384.  
  385.  
  386. example:
  387.  
  388.  
  389.  
  390. program examp2;
  391.  
  392. {$Ipchr.i  }   { The include file that contains the definitions of the }
  393.                { character graphics routines.  THE SPACES AFTER THE .i }
  394.                { EXTENSION MUST BE INCLUDED }
  395.  
  396. var
  397.       shapes : charset;
  398.       window1,window2,window3 : charmessage;
  399.                          { Note:  if you want to save space, the definition }
  400.                          { of CHARMESSAGE can be changed to a smaller array }
  401.       i,m,n,p,errno,delay,delta : integer;
  402.                              { loop indices and such }
  403.       ch : char;             { a character for user response }
  404.  
  405. begin  { main program }
  406.    errno := readcset(shapes,'slotmchn.chr');
  407.                              { read the character set }
  408.    if errno <> -1 then       { if all is ok }
  409.       begin
  410.          graphcolormode;     { set 320 x 200 graphics }
  411.          gotoxy(1,20);
  412.          writeln('Press the Space Bar to roll again');
  413.                              { let the user know what to do }
  414.          getvect;            { save the system vector }
  415.          setvect(shapes);    { and put in our own }
  416.          for i := 0 to 4 do  { set up the bells and whistles (and cherries }
  417.             begin            { and lemons and... }
  418.                window1[i] := i;   { use these characters }
  419.                window2[i] := i+10;
  420.                window3[i] := i+20;
  421.             end;
  422.          for i := 0 to 4 do
  423.             begin
  424.                copychar(shapes,window1[i],window2[i]);
  425.                              { copy the pictures from window1 to window 2 }
  426.                copychar(shapes,window1[i],window3[i]);
  427.                              { and window 3 }
  428.             end;
  429.          repeat              { now do the display }
  430.             i := 8*(random(11)+5);
  431.                              { spin window 1 5 to 15 times (8 rows/char) }
  432.             m := i+8*(random(6)+5);
  433.                              { window 2 spins a little longer }
  434.             n := m+8*(random(6)+5);
  435.                              { and window 3 longer yet }
  436.             printcolumn(5,10,window1,1,3);
  437.                              { display the initial characters }
  438.             printcolumn(5,15,window2,1,3);
  439.             printcolumn(5,20,window3,1,3);
  440.                              { Note: for displaying 1 character, gratchar }
  441.                              { could also be used. }
  442.                              { e.g. gratchar(5,x,windowx[0],3) }
  443.             delay := 0;      { start off fast }
  444.             repeat
  445.                if i <> 0 then    { each window rolls its own number of times }
  446.                   begin
  447.                      columndown(shapes,window1,5);  { roll window }
  448.                      i := i-1;   { count it }
  449.                      if i = 0 then
  450.                         delay := delay+50;
  451.                                  { if this window is not going to roll }
  452.                                  { anymore, make up for the processing }
  453.                                  { time lost not updating it }
  454.                   end;
  455.                if m <> 0 then    { this looks just like the previous one }
  456.                   begin
  457.                      columndown(shapes,window2,5);
  458.                      m := m-1;
  459.                      if m = 0 then
  460.                         delay := delay+50;
  461.                   end;
  462.                columndown(shapes,window3,5);
  463.                n := n-1;  { the 3rd window needs no fancy processing, as we }
  464.                           { know it will be spinning to the very end }
  465.                for delta := 0 to delay do ;  { waste a little time }
  466.                delay := delay+10;    { waste a little more time next time }
  467.                printcolumn(5,10,window1,1,3);  { update the windows }
  468.                printcolumn(5,15,window2,1,3);
  469.                printcolumn(5,20,window3,1,3);
  470.             until n = 0;  { end of inner repeat loop }
  471.             read(kbd,ch); { get the users response }
  472.          until ch <> ' '; { and repeat until it is not a space }
  473.          restorevect;     { put the system vector back }
  474.          textmode;        { restore the regular screen }
  475.       end;                { of the if statement }
  476. end.                      { end of the program }
  477.